uses Math;

type point = record
  x,y : extended;
end;

const 
	eps = 1e-7;
	inf = 1e9;

function eq(a,b : extended) : boolean;
begin
	eq := abs(a-b) <= eps;
end;

function mp(x,y : extended) : point;
begin
  mp.x := x; mp.y := y;
end;

function Ferma(a,b,c : point) : point;
var s,d,p,q : extended;
  function rev(a : point) : point;
	begin
		rev.x := a.y; rev.y := a.x;
	end;
  function area(a,b,c : point) : extended;
  begin
		area := (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
  end;
	function clock_wise(a,b,c : point) : boolean;
	begin
		clock_wise := area(a,b,c) < 0;
	end;
	procedure swap(var a,b : point);
	var c : point;
	begin
		c := a; a := b; b := c;
	end;
	function dist2(a,b : point) : extended;
	begin
		dist2 := (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y);
	end;
	function magic(a,b,c : point; mb : extended) : extended;
	begin
		magic := sqrt(3)*(a.x*dist2(b,c) + b.x*dist2(a,c) + c.x*dist2(a,b)) - (a.x+b.x+c.x)*s +
		         mb*3*((a.y-b.y)*(a.x*b.x+a.y*b.y) + (c.y-a.y)*(a.x*c.x+a.y*c.y) + (b.y-c.y)*(b.x*c.x+b.y*c.y));
	end;
begin
	if not clock_wise(a,b,c) then swap(a,b);
	s := area(a,b,c);
	d := dist2(a,b)/2 + dist2(a,c)/2 + dist2(b,c)/2 + sqrt(3)*abs(s);
	p := magic(a,b,c,+1);
	q := magic(rev(a),rev(b),rev(c),-1);
	Ferma.x := p / (2*sqrt(3)*d);
	Ferma.y := q / (2*sqrt(3)*d);
end;

function dist(a,b : point) : extended;
begin
	dist := sqrt((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
end;

function online(a,b,c : point) : boolean;
begin
	online := eq((c.x-a.x)*(b.y-a.y), (c.y-a.y)*(b.x-a.x));
end;

function PolarAngle(x,y : extended) : extended;
var p : extended;
begin
  p:=ArcTan2(y,x);
  if p<0 then p:=p+2*Pi;
  PolarAngle:=p;
End;

function ADiff(a,b : extended) : extended;
begin
	if b>=a then ADiff:=b-a else ADiff:=b-a+2*Pi;
end;

function PPAngle(p1,p2 : point) : extended;
begin
  PPAngle:=PolarAngle(p2.x-p1.x,p2.y-p1.y);
end;

function Angle(p,p1,p2 : point) : extended;
var a : extended;
begin
  a := ADiff(PPAngle(P,P1),PPAngle(P,P2));
	if a<=pi then Angle:=a else Angle:=a-2*Pi;
end;

function good(a,b,c : point) : boolean;
begin
	good := not online(a,b,c) and (abs(angle(a,b,c)) < 2*pi/3) and (abs(angle(b,c,a)) < 2*pi/3) and (abs(angle(c,a,b)) < 2*pi/3);
end;


var p : array [0..250] of point;
		n,m : integer;
		i,j,q,p1,p2,p3 : integer;

		ans : point;
		ansl : extended;
		ansv : array [1..250,1..2] of integer;
		ansvs : integer;

procedure prim(n : integer; using : boolean);
var 
	used : array [0..250] of boolean;
	min_e : array [0..250] of extended;
	sel_e : array [0..250] of integer;
	i,j,v : integer;
	cansv : array[1..250,1..2] of integer;
	cansvs : integer;
	cansl : extended;
	function g(a,b : integer) : extended;
	begin
		g := dist(p[a], p[b]);
	end;
begin
	for i := 0 to 250 do used[i] := false;
	for i := 0 to 250 do min_e[i] := inf;
	for i := 0 to 250 do sel_e[i] := -1;
	min_e[0] := 0;
	cansvs := 0;
	cansl := 0;
	for i := 0 to n-1 do
		begin
			v := -1;
			for j := 0 to n-1 do
				if not used[j] and ((v = -1) or (min_e[j] < min_e[v])) then v := j;
			used[v] := true;
			if sel_e[v] <> -1 then
				begin
					inc(cansvs);
					cansv[cansvs,1] := v;
					cansv[cansvs,2] := sel_e[v];
					cansl := cansl + g(v, sel_e[v]);
				end;
			for j := 0 to n-1 do
				if g(v,j) < min_e[j] then
					begin
						min_e[j] := g(v,j);
						sel_e[j] := v;
					end;
		end;
	if cansl < ansl then
		begin
			ansl := cansl;
			if using then ans := p[n-1];
			for i := 1 to n-1 do
				begin
					ansv[i,1] := cansv[i,1];
					ansv[i,2] := cansv[i,2];
				end;
			ansvs := cansvs;
		end;
end;

var ta : array [0..3] of integer;
		tp : integer;
		ok : boolean;

begin
	//assign(input, 'input.txt'); reset(input);
	//assign(output, 'output.txt'); rewrite(output);
	read(n);
	for i := 0 to n-1 do
		read(p[i].x, p[i].y);
	ansl := inf;
	prim(n,false);
	
	if n <= 30 then
	for p1 := 0 to n-1 do
		for p2 := p1+1 to n-1 do
			for p3 := p2+1 to n-1 do
				begin
					if good(p[p1],p[p2],p[p3]) then
						begin
							p[n] := Ferma(p[p1],p[p2],p[p3]);
							ok := true;
							for i := 0 to n-1 do
								if eq(p[i].x,p[n].x) and eq(p[i].y,p[n].y) then ok := false;
							if ok then
								prim(n+1,true);
						end;
				end;

	writeln(ansl);
	writeln(ans.x,' ',ans.y);
	ta[0] := 0;
	for i := 1 to ansvs do
		if (ansv[i,1] = n) or (ansv[i,2] = n) then
			begin
				inc(ta[0]);
				if ansv[i,1] = n then ta[ta[0]] := ansv[i,2] else ta[ta[0]] := ansv[i,1];
			end;
	write(ta[0]);
	for i := 1 to ta[0] do write(' ',ta[i]+1);
	writeln;
	tp := 0;
	for i := 1 to ansvs do
		if (ansv[i,1] <> n) and (ansv[i,2] <> n) then
			inc(tp);
	writeln(tp);
	for i := 1 to ansvs do
		if (ansv[i,1] <> n) and (ansv[i,2] <> n) then
			writeln(ansv[i,1]+1,' ',ansv[i,2]+1);
end.
